
applicationContext.refresh()
	registerBeanPostProcessors(beanFactory) // 注入BeanPostProcessor;将所有BeanPostProcessor类导入Spring容器中
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, applicationContext)	
			String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
			
			int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
			beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

			List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
			List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
			List<String> orderedPostProcessorNames = new ArrayList<String>();
			List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
			
			// 分类收集priorityOrderedPostProcessors，internalPostProcessors，orderedPostProcessorNames，nonOrderedPostProcessorNames
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);// ☆
					priorityOrderedPostProcessors.add(pp);
					if (pp instanceof MergedBeanDefinitionPostProcessor) {
						internalPostProcessors.add(pp);
					}
				}
				else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
					orderedPostProcessorNames.add(ppName);
				}
				else {
					nonOrderedPostProcessorNames.add(ppName);
				}
			}

			// 排序并注册priorityOrderedPostProcessor
			sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
			registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

			// 排序并注册orderedPostProcessor
			List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
			for (String ppName : orderedPostProcessorNames) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); // ☆
				orderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			sortPostProcessors(orderedPostProcessors, beanFactory);
			registerBeanPostProcessors(beanFactory, orderedPostProcessors);

			// 注册nonOrderedPostProcessor
			List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
			for (String ppName : nonOrderedPostProcessorNames) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); // ☆
				nonOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

			// 排序注册internalPostProcessors
			sortPostProcessors(internalPostProcessors, beanFactory);
			registerBeanPostProcessors(beanFactory, internalPostProcessors);

			// Re-register post-processor for detecting inner beans as ApplicationListeners,
			// moving it to the end of the processor chain (for picking up proxies etc).
			beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
			
			/**
			 * beanFactory.beanPostProcessors顺序(AnnotationAwareOrderComparator)：
			 * BeanPostProcessorChecker
			 * priorityOrderedPostProcessors[]
			 * orderedPostProcessors[]
			 * nonOrderedPostProcessors[]
			 * internalPostProcessors[]
			 * ApplicationListenerDetector
			 */		
			 
	finishBeanFactoryInitialization(beanFactory); // 实例化其他类型的非延迟的普通bean
		beanFactory.preInstantiateSingletons()
			
			// 初始化所有非懒加载的bean
			for (String beanName : beanNames) {
				RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
				if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
					if (isFactoryBean(beanName)) {
						final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
								@Override
								public Boolean run() {
									return ((SmartFactoryBean<?>) factory).isEagerInit();
								}
							}, getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
					else {
						getBean(beanName);
					}
				}
			}
			
			// 对SmartInitializingSingleton进行初始化会掉操作
			for (String beanName : beanNames) {
				Object singletonInstance = getSingleton(beanName);
				if (singletonInstance instanceof SmartInitializingSingleton) {
					final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
					if (System.getSecurityManager() != null) {
						AccessController.doPrivileged(new PrivilegedAction<Object>() {
							@Override
							public Object run() {
								smartSingleton.afterSingletonsInstantiated();
								return null;
							}
						}, getAccessControlContext());
					}
					else {
						smartSingleton.afterSingletonsInstantiated();
					}
				}
			}
			
			
BeanFactroy获取bean
beanFactory.getBean(String name, Class<T> requiredType)
	doGetBean(name, requiredType, args, typeCheckOnly)
		getSingleton(beanName, new ObjectFactory<Object>())
			createBean(beanName, mbd, args)
				Object bean = resolveBeforeInstantiation(beanName, mbdToUse);// 这里实例化bean和在bean前后进行拦截操作 
								Object bean = null;
								if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
									// Make sure bean class is actually resolved at this point.
									if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
										Class<?> targetType = determineTargetType(beanName, mbd);
										if (targetType != null) {
											bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
													for (BeanPostProcessor bp : getBeanPostProcessors()) {
														if (bp instanceof InstantiationAwareBeanPostProcessor) {
															InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
															Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
															if (result != null) {
																return result;
															}
														}
													}
													return null;
											if (bean != null) {
												bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
														Object result = existingBean;
														for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
															result = beanProcessor.postProcessAfterInitialization(result, beanName);
															if (result == null) {
																return result;
															}
														}
														return result;
											}
										}
									}
									mbd.beforeInstantiationResolved = (bean != null);
								}
								return bean;
				if (bean != null) {
					return bean;
				}
				doCreateBean(beanName, mbdToUse, args)
					instanceWrapper = createBeanInstance(beanName, mbd, args)
										// TODO XXXX
					populateBean(beanName, mbd, instanceWrapper)
						// TODO .............
						if (hasInstAwareBpps || needsDepCheck) {
							PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
							if (hasInstAwareBpps) {
								for (BeanPostProcessor bp : getBeanPostProcessors()) {
									if (bp instanceof InstantiationAwareBeanPostProcessor) {
										InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
										pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
										if (pvs == null) {
											return;
										}
									}
								}
							}
							if (needsDepCheck) {
								checkDependencies(beanName, mbd, filteredPds, pvs);
							}
						}
						// TODO .............
						
					
					exposedObject = initializeBean(beanName, exposedObject, mbd)
						invokeAwareMethods(beanName, bean); // 调用Aware的方法，给实现类获取数据的能力
							if (bean instanceof Aware) {
								if (bean instanceof BeanNameAware) {
									((BeanNameAware) bean).setBeanName(beanName);
								}
								if (bean instanceof BeanClassLoaderAware) {
									((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
								}
								if (bean instanceof BeanFactoryAware) {
									((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
								}
							}
						wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);// 初始化之前执行
										Object result = existingBean;
										for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
											result = beanProcessor.postProcessBeforeInitialization(result, beanName);
											if (result == null) {
												return result;
											}
										}
										return result;
						invokeInitMethods(beanName, wrappedBean, mbd); // 初始化@postconStruct,@preDestroy
						wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);// 初始化之后执行
										Object result = existingBean;
										for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
											result = beanProcessor.postProcessAfterInitialization(result, beanName);
											if (result == null) {
												return result;
											}
										}
										return result;
						return wrappedBean;
					return exposedObject;
					
					
					
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */					
InstantiationAwareBeanPostProcessor extends BeanPostProcessor
	Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;
	boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;
	PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException;

BeanPostProcessor
	Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
	Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

BeanFactoryAware extends Aware
	void setBeanFactory(BeanFactory beanFactory) throws BeansException;

	
调试断点思维角度：
创建代理过程：实例化->初始化前->初始化后(在这里使用Cglib进行代码织入)
AnnotationAwareAspectJAutoProxyCreator创建Bean代理对象：
			AbstractAutoProxyCreator
				@Override
				public void setBeanFactory(BeanFactory beanFactory) {
					this.beanFactory = beanFactory;
				}
				@Override
				public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
					Object cacheKey = getCacheKey(beanClass, beanName);

					if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
						if (this.advisedBeans.containsKey(cacheKey)) {
							return null;
						}
						//isInfrastructureClass：判断是否是切面类(Advice,Pointcut,Advisor,AopInfrastructureBean)
						if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
							this.advisedBeans.put(cacheKey, Boolean.FALSE);
							return null;
						}
					}

					// Create proxy here if we have a custom TargetSource.
					// Suppresses unnecessary default instantiation of the target bean:
					// The TargetSource will handle target instances in a custom fashion.
					if (beanName != null) {
						TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
						if (targetSource != null) {
							this.targetSourcedBeans.add(beanName);
							Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
							Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
							this.proxyTypes.put(cacheKey, proxy.getClass());
							return proxy;
						}
					}

					return null;
				}
				@Override
				public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
					if (bean != null) {
						Object cacheKey = getCacheKey(bean.getClass(), beanName);
						if (!this.earlyProxyReferences.contains(cacheKey)) {
							return wrapIfNecessary(bean, beanName, cacheKey);
									if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
										return bean;
									}
									if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
										return bean;
									}
									if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
										this.advisedBeans.put(cacheKey, Boolean.FALSE);
										return bean;
									}

									// Create proxy if we have advice.
									Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
									if (specificInterceptors != DO_NOT_PROXY) {
										this.advisedBeans.put(cacheKey, Boolean.TRUE);
										Object proxy = createProxy(
												bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
														if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
															AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
														}
														
														// 构建proxyFactory
														ProxyFactory proxyFactory = new ProxyFactory();
														proxyFactory.copyFrom(this);

														if (!proxyFactory.isProxyTargetClass()) {
															if (shouldProxyTargetClass(beanClass, beanName)) {
																proxyFactory.setProxyTargetClass(true);
															}
															else {
																evaluateProxyInterfaces(beanClass, proxyFactory);
															}
														}

														// 构建advisors和targetSource到proxyFactory
														Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
														proxyFactory.addAdvisors(advisors);
														proxyFactory.setTargetSource(targetSource);
														customizeProxyFactory(proxyFactory);

														proxyFactory.setFrozen(this.freezeProxy);
														if (advisorsPreFiltered()) {
															proxyFactory.setPreFiltered(true);
														}
														
														// 获取proxy对象
														return proxyFactory.getProxy(getProxyClassLoader());
															return createAopProxy().getProxy(classLoader);
																// 确定使用jdk还是cglib代理方式
																createAopProxy(AdvisedSupport config)
																	if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
																		Class<?> targetClass = config.getTargetClass();
																		if (targetClass == null) {
																			throw new AopConfigException("TargetSource cannot determine target class: " +
																					"Either an interface or a target is required for proxy creation.");
																		}
																		// targetClass是接口或者是proxy类
																		if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
																			return new JdkDynamicAopProxy(config);
																		}
																		return new ObjenesisCglibAopProxy(config);
																	}
																	else {
																		return new JdkDynamicAopProxy(config);
																	}
																CglibAopProxy.getProxy(classLoader) // 这里使用cglib方式获取代理对象
										this.proxyTypes.put(cacheKey, proxy.getClass());
										return proxy;
									}

									this.advisedBeans.put(cacheKey, Boolean.FALSE);
									return bean;
						}
					}
					return bean;
				}
		AbstractAdvisorAutoProxyCreator
			public void setBeanFactory(BeanFactory beanFactory) {
				super.setBeanFactory(beanFactory);
				if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
					throw new IllegalArgumentException(
							"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
				}
				initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
			}
	AspectJAwareAdvisorAutoProxyCreator
AnnotationAwareAspectJAutoProxyCreator


拦截器链：
// 织入后的目标兑现类型
class com.walleipt.demo.aop.aspectj.Printer$$EnhancerBySpringCGLIB$$a4f72797


// CglibAopProxy对象拦截器
CglibAopProxy$DynamicAdvisedInterceptor.intercept(Object, Method, Object[], MethodProxy)
	Object oldProxy = null;
	boolean setProxyContext = false;
	Class<?> targetClass = null;
	Object target = null;
	try {
		if (this.advised.exposeProxy) {
			oldProxy = AopContext.setCurrentProxy(proxy);
			setProxyContext = true;
		}
		
		target = getTarget();
		if (target != null) {
			targetClass = target.getClass();
		}
		
		// chain就是List<Interceptor/MethodInterceptor>
		List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
											List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
											Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
											boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
											AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();

											for (Advisor advisor : config.getAdvisors()) {
												if (advisor instanceof PointcutAdvisor) {
													// Add it conditionally.
													PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
													if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
														MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
														MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
														if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
															if (mm.isRuntime()) {
																// Creating a new object instance in the getInterceptors() method
																// isn't a problem as we normally cache created chains.
																for (MethodInterceptor interceptor : interceptors) {
																	interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
																}
															}
															else {
																interceptorList.addAll(Arrays.asList(interceptors));
															}
														}
													}
												}
												else if (advisor instanceof IntroductionAdvisor) {
													IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
													if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
														Interceptor[] interceptors = registry.getInterceptors(advisor);
														interceptorList.addAll(Arrays.asList(interceptors));
													}
												}
												else {
													Interceptor[] interceptors = registry.getInterceptors(advisor);
													interceptorList.addAll(Arrays.asList(interceptors));
												}
											}

											return interceptorList;
		Object retVal;
		
		if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
			Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);		
			retVal = methodProxy.invoke(target, argsToUse);
		}
		else {
			// 拦截器链;使用MethodInvocation.proceed()递归调用interceptor.invoke()
			retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
							MethodInvocation.proceed():
								// 递归达到条件跳出
								if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
									return invokeJoinpoint();
								}

								Object interceptorOrInterceptionAdvice =
										this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
								if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
									// Evaluate dynamic method matcher here: static part will already have
									// been evaluated and found to match.
									InterceptorAndDynamicMethodMatcher dm =
											(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
									if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
										return dm.interceptor.invoke(this);
									}
									else {
										// Dynamic matching failed.
										// Skip this interceptor and invoke the next in the chain.
										return proceed();
									}
								}
								else {
									// 使用递归的方式调用Interceptor.invok()方法
									return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
								}
		}
		retVal = processReturnType(proxy, target, method, retVal);
		return retVal;
	}
	finally {
		if (target != null) {
			releaseTarget(target);
		}
		if (setProxyContext) {
			// Restore old proxy.
			AopContext.setCurrentProxy(oldProxy);
		}
	}


// 拦截链【chain=List<Interceptor/MethodInterceptor>】
a.代码使用来的递归嵌套的方式；
b.AspectJAfterThrowingAdvice这里的有异常catch，如果方法执行发生异常会把异常放入这个catch中的代码块中；	
[0]	ExposeInvocationInterceptor.invoke(MethodInvocation mi)
	MethodInvocation oldInvocation = invocation.get(); // ☆ invocation是ThreadLoacl对象
	invocation.set(mi);
	try {
		return mi.proceed();
	}
	finally {
		invocation.set(oldInvocation);
	}
[1]	AspectJAfterThrowingAdvice.invoke(MethodInvocation mi)
	try {
		return mi.proceed();
	}
	catch (Throwable ex) {
		if (shouldInvokeOnThrowing(ex)) {
			invokeAdviceMethod(getJoinPointMatch(), null, ex);
		}
		throw ex;
	}
[2]	AfterReturningAdviceInterceptor.invoke(MethodInvocation mi)
	Object retVal = mi.proceed();
	this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
	return retVal;
[3]	AspectJAfterAdvice.invoke(MethodInvocation mi)
	try {
		return mi.proceed();
	}
	finally {
		invokeAdviceMethod(getJoinPointMatch(), null, null);
	}
[4]	MethodBeforeAdviceInterceptor.invoke(MethodInvocation mi)
	this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
	return mi.proceed();



事物使用AOP方式进行
TransactionInterceptor.invoker()
	Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
	return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
		@Override
		public Object proceedWithInvocation() throws Throwable {
			return invocation.proceed();
		}
	});
		TransactionAspectSupport.invokeWithinTransaction()
			if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
				 
				TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
				Object retVal = null;
				try {
					// 调用proceed方式；其实就是执行将目标方法了(这里可以增加aop loger观察多个interceptor的顺序)
					retVal = invocation.proceedWithInvocation();
				}
				catch (Throwable ex) {
					// 捕获异常进行事物回滚操作
					completeTransactionAfterThrowing(txInfo, ex);
					throw ex;
				}
				finally {
					cleanupTransactionInfo(txInfo);
				}
				commitTransactionAfterReturning(txInfo);
				return retVal;
			}
			else {
				final ThrowableHolder throwableHolder = new ThrowableHolder();

				// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
				try {
					Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
							new TransactionCallback<Object>() {
								@Override
								public Object doInTransaction(TransactionStatus status) {
									TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
									try {
										return invocation.proceedWithInvocation();
									}
									catch (Throwable ex) {
										if (txAttr.rollbackOn(ex)) {
											// A RuntimeException: will lead to a rollback.
											if (ex instanceof RuntimeException) {
												throw (RuntimeException) ex;
											}
											else {
												throw new ThrowableHolderException(ex);
											}
										}
										else {
											// A normal return value: will lead to a commit.
											throwableHolder.throwable = ex;
											return null;
										}
									}
									finally {
										cleanupTransactionInfo(txInfo);
									}
								}
							});

					// Check result state: It might indicate a Throwable to rethrow.
					if (throwableHolder.throwable != null) {
						throw throwableHolder.throwable;
					}
					return result;
				}
				catch (ThrowableHolderException ex) {
					throw ex.getCause();
				}
				catch (TransactionSystemException ex2) {
					if (throwableHolder.throwable != null) {
						logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
						ex2.initApplicationException(throwableHolder.throwable);
					}
					throw ex2;
				}
				catch (Throwable ex2) {
					if (throwableHolder.throwable != null) {
						logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
					}
					throw ex2;
				}
			}



a.beforeInit()动态代理构建出含有Intercepot的目标对象
b.执行方法()需要在cglib的Interceopt中执行自定义的Interceopt中的方法

